/**
 * API服务工具类
 * 统一管理HTTP请求和响应处理
 */

import { APP_CONFIG, API_PATHS, utils } from './config.js'

// API基础配置
const API_CONFIG = {
	baseURL: APP_CONFIG.API_BASE_URL,
	timeout: APP_CONFIG.API_TIMEOUT,
	header: {
		'Content-Type': 'application/json'
	}
}

/**
 * 处理登录重定向
 */
function handleLoginRedirect() {
	console.log('API层检测到登录重定向')
	uni.showModal({
		title: '登录提示',
		content: '登录已过期，请重新登录',
		showCancel: false,
		confirmText: '去登录',
		success: () => {
			// 清除本地存储的登录信息
			uni.removeStorageSync('asurada_user_token')
			uni.removeStorageSync('asurada_user_info')
			
			// 跳转到登录页面
			uni.reLaunch({
				url: '/pages/login/login'
			})
		}
	})
}

/**
 * 统一请求方法
 * @param {Object} options 请求配置
 */
function request(options) {
	return new Promise((resolve, reject) => {
		// 显示加载提示
		if (options.showLoading !== false) {
			uni.showLoading({
				title: options.loadingText || '请求中...',
				mask: true
			})
		}

		// 获取当前令牌
		const token = uni.getStorageSync('asurada_user_token')
		const headers = {
			...API_CONFIG.header,
			...options.header
		}
		
		// 添加认证头
		headers['Authorization'] = `Bearer ${token}` ;
		headers['X-Refresh-Token'] = uni.getStorageSync('refresh_token');
		headers['X-Im-access-Token'] = uni.getStorageSync('im_access_token');
		headers['X-Im-session-Token'] = uni.getStorageSync('im_session_token');





		// 发起请求
		uni.request({
			url: API_CONFIG.baseURL + options.url,
			method: options.method || 'GET',
			data: options.data || {},
			header: headers,
			timeout: options.timeout || API_CONFIG.timeout,
			withCredentials: true, // 启用Cookie支持
			success: (res) => {
				// 隐藏加载提示
				if (options.showLoading !== false) {
					uni.hideLoading()
				}

				// 检查是否需要重定向到登录页面
				if (res.statusCode === 200 && typeof res.data === 'string' && res.data.includes('/login')) {
					console.log('API层检测到登录重定向:', res.data)
					handleLoginRedirect()
					return
				}

				// 处理响应
				if (res.statusCode === 200) {
					const result = res.data
					if (result.code === 200) {
						resolve(result)
					} else {
						// 业务错误
						const errorMsg = result.message || '请求失败'
						if (options.showError !== false) {
							uni.showToast({
								title: errorMsg,
								icon: 'none',
								duration: 2000
							})
						}
						reject(new Error(errorMsg))
					}
				} else if (res.statusCode === 403) {
					// 处理403 Forbidden错误
					const errorMsg = '访问被拒绝，可能是CORS策略限制或权限不足'
					utils.log('error', '403 Forbidden错误', {
						url: options.url,
						method: options.method || 'GET'
					})
					if (options.showError !== false) {
						uni.showToast({
							title: errorMsg,
							icon: 'none',
							duration: 3000
						})
					}
					reject(new Error(errorMsg))
				} else {
					// 其他HTTP错误
					const errorMsg = `请求失败 (${res.statusCode})`
					if (options.showError !== false) {
						uni.showToast({
							title: errorMsg,
							icon: 'none',
							duration: 2000
						})
					}
					reject(new Error(errorMsg))
				}
			},
			fail: (err) => {
				// 隐藏加载提示
				if (options.showLoading !== false) {
					uni.hideLoading()
				}

				// 详细的网络错误处理
				let errorMsg = '网络连接失败'
				
				if (err.errMsg) {
					if (err.errMsg.includes('timeout')) {
						errorMsg = '请求超时，请检查网络连接'
					} else if (err.errMsg.includes('fail')) {
						errorMsg = '网络请求失败，请检查服务器状态'
					} else if (err.errMsg.includes('abort')) {
						errorMsg = '请求被取消'
					} else {
						errorMsg = err.errMsg
					}
				}
				
				utils.log('error', '网络请求失败', {
					url: API_CONFIG.baseURL + options.url,
					method: options.method || 'GET',
					error: err
				})
				
				if (options.showError !== false) {
					uni.showToast({
						title: errorMsg,
						icon: 'none',
						duration: 3000
					})
				}
				reject(err)
			}
		})
	})
}

/**
 * GET请求
 */
function get(url, params = {}, options = {}) {
	return request({
		url,
		method: 'GET',
		data: params,
		...options
	})
}

/**
 * POST请求
 */
function post(url, data = {}, options = {}) {
	return request({
		url,
		method: 'POST',
		data,
		...options
	})
}

/**
 * PUT请求
 */
function put(url, data = {}, options = {}) {
	return request({
		url,
		method: 'PUT',
		data,
		...options
	})
}

/**
 * DELETE请求
 */
function del(url, params = {}, options = {}) {
	return request({
		url,
		method: 'DELETE',
		data: params,
		...options
	})
}

// 用户认证相关API
const authAPI = {
	/**
	 * 获取登录授权码
	 * @param {Object} loginData 登录数据
	 * @param {String} loginData.phone 手机号
	 * @param {String} loginData.password 密码
	 */
	getLoginAuthCode(loginData) {
		// 转换为后端期望的格式（UserLoginDto）
		const requestData = {
			account: loginData.phone, // 后端使用account字段接收手机号
			password: loginData.password
		}
		
		utils.log('info', '获取登录授权码请求', { account: requestData.account })
		return post(API_PATHS.LOGIN, requestData, {
			loadingText: '验证中...'
		})
	},

	/**
	 * 获取登录令牌
	 * @param {Object} loginData 登录数据
	 * @param {String} loginData.authCode 授权码
	 */
	getLoginToken(loginData,authCode) {
		// 将授权码放入请求头
		const headers = {
			'X-Auth-Code': authCode
		};

		const requestData = {
			account: loginData.phone,
			password: loginData.password
		};
		
		utils.log('info', '获取登录令牌请求')
		return post(API_PATHS.TOKEN, requestData, {
			loadingText: '登录中...',
			header: headers,

		})
	},

	/**
	 * 用户登录（两步登录流程）
	 * @param {Object} loginData 登录数据
	 * @param {String} loginData.phone 手机号
	 * @param {String} loginData.password 密码
	 */
	async login(loginData) {
		// 第一步：获取登录授权码
		const authResult = await this.getLoginAuthCode(loginData)
		
		if (authResult.code === 200 && authResult.data) {
			// 第二步：使用相同的登录数据获取令牌（后端会从Cookie中读取authCode）
			const tokenResult = await this.getLoginToken(loginData)
			return tokenResult
		} else {
			throw new Error(authResult.message || '获取登录授权码失败')
		}
	},

	/**
	 * 验证码登录
	 * @param {Object} loginData 登录数据
	 * @param {String} loginData.phone 手机号
	 * @param {String} loginData.code 验证码
	 */
	loginByCode(loginData) {
		// 转换为后端期望的格式
		const requestData = {
			phone: loginData.phone,
			code: loginData.code
		}
		
		utils.log('info', '验证码登录请求', { phone: requestData.phone })
		return post(API_PATHS.LOGIN_BY_CODE, requestData, {
			loadingText: '登录中...'
		})
	},

	/**
	 * 用户登出
	 */
	logout() {
		utils.log('info', '用户登出请求')
		return post(API_PATHS.LOGOUT, {}, {
			loadingText: '登出中...'
		})
	},

	/**
	 * 刷新令牌
	 */
	refreshToken() {
		utils.log('debug', '刷新令牌请求')
		return post(API_PATHS.REFRESH_TOKEN, {}, {
			showLoading: false,
			showError: false
		})
	},

	/**
	 * 获取用户信息
	 */
	getUserInfo() {
		utils.log('debug', '获取用户信息请求')
		return get(API_PATHS.GET_USER_INFO, {}, {
			showLoading: false
		})
	},

	/**
	 * 验证令牌
	 */
	verifyToken() {
		utils.log('debug', '验证令牌请求')
		return get(API_PATHS.VERIFY_TOKEN, {}, {
			showLoading: false,
			showError: false
		})
	},

	/**
	 * 检查登录状态
	 */
	checkLoginStatus() {
		utils.log('debug', '检查登录状态请求')
		return get(API_PATHS.CHECK_LOGIN_STATUS, {}, {
			showLoading: false,
			showError: false
		})
	}
}

// 用户管理相关API
const userAPI = {
	/**
	 * 用户注册
	 * @param {Object} registerData 注册数据
	 */
	register(registerData) {
		utils.log('info', '用户注册请求', { username: registerData.username, mobile: registerData.mobile })
		
		const requestUrl = API_PATHS.REGISTER
		utils.log('debug', `注册请求URL: ${requestUrl}`)
		
		const requestData = {
			username: registerData.username,
			password: registerData.password,
			email: registerData.email,
			mobile: registerData.mobile
		}
		
		return new Promise((resolve, reject) => {
			uni.showLoading({
				title: '注册中...',
				mask: true
			})
			
			uni.request({
				url: API_CONFIG.baseURL + requestUrl,
				method: 'POST',
				data: requestData,
				header: {
					'Content-Type': 'application/json'
				},
				success: (res) => {
					uni.hideLoading()
					utils.log('debug', '注册响应', res)
					
					if (res.statusCode === 200) {
						resolve(res.data)
					} else {
						let errorMsg = '注册失败'
						if (res.data && res.data.message) {
							errorMsg = res.data.message
						} else if (res.statusCode === 403) {
							errorMsg = '注册请求被拒绝，可能是跨域问题'
						} else if (res.statusCode === 404) {
							errorMsg = '注册接口不存在'
						}
						
						uni.showToast({
							title: errorMsg,
							icon: 'none',
							duration: 2000
						})
						
						reject(new Error(errorMsg))
					}
				},
				fail: (err) => {
					uni.hideLoading()
					utils.log('error', '注册请求失败', err)
					
					let errorMsg = '网络请求失败'
					if (err.errMsg) {
						if (err.errMsg.includes('timeout')) {
							errorMsg = '请求超时，请检查网络连接'
						} else if (err.errMsg.includes('fail')) {
							errorMsg = '网络请求失败，请检查服务器状态'
						}
					}
					
					uni.showToast({
						title: errorMsg,
						icon: 'none',
						duration: 2000
					})
					
					reject(new Error(errorMsg))
				}
			})
		})
	},

	/**
	 * 发送验证码
	 * @param {String} phone 手机号
	 * @param {String} type 验证码类型 (login/register)
	 */
	sendVerificationCode(phone, type = 'login') {
		utils.log('info', '发送验证码请求', { phone, type })
		return get(API_PATHS.SEND_SMS, { phone }, {
			loadingText: '发送中...'
		}).catch(error => {
			if (error.message && error.message.includes('404')) {
				throw new Error('短信验证码功能暂未开放，请联系管理员')
			}
			throw error
		})
	},

	/**
	 * 验证手机验证码
	 * @param {String} phone 手机号
	 * @param {String} code 验证码
	 * @param {String} type 验证码类型
	 */
	verifyCode(phone, code, type = 'login') {
		utils.log('debug', '验证验证码请求', { phone, type })
		return post(API_PATHS.VERIFY_SMS, { phone, code, type }, {
			showLoading: false
		}).catch(error => {
			if (error.message && error.message.includes('404')) {
				throw new Error('验证码验证功能暂未开放，请联系管理员')
			}
			throw error
		})
	}
}

// 聊天相关API
const chatAPI = {
	/**
	 * 获取聊天历史记录
	 * @param {String} memoryId 聊天记录ID（用户ID）
	 */
	getChatHistory(memoryId) {
		utils.log('debug', '获取聊天历史记录请求', { memoryId })
		return get(API_PATHS.GET_CHAT_HISTORY, { memoryId }, {
			showLoading: false
		})
	}
}

// 导出API方法
export {
	request,
	get,
	post,
	put,
	del,
	authAPI,
	userAPI,
	chatAPI,
	API_CONFIG
}

export default {
	request,
	get,
	post,
	put,
	del,
	auth: authAPI,
	user: userAPI,
	chat: chatAPI,
	config: API_CONFIG
}